////I STARTED THIS CLASS BECAUSE I THOUGHT RULETANGLE IS NOT GOOD ENOUGH. I WAS WRONG.
//
//#include "rectangle.h"
//#include "pixelhistory.h"
//
//#ifndef RULEPTION_H_
//#define RULEPTION_H_
//
///**
// * This class represents one rule with exceptions. It says IF the history of the given pixel is this, then the state
// * of the pixel in the next phase should be this, UNLESS that pixel has this coordinate. it stores the exception coordinates 
// * in a vector of rectangles.
// */
//class Ruleption
//{
//private:
//	PixelHistory ifPart;				//!< The history of the given pixel. works as the blub blub blub in: IF history of the pixel is blub blub blub...
//	int MajorLabel;						//!< The first judgement of this Ruleption. Works as the shit in: THEN the label is shit
//	vector<Rectangle> main;				//!< The vector of the main rectangles. It is only used to form the exceptions, so that they do not cover major occurances.
//	vector<Rectangle> exception;	 	//!< The vector of rectangles where the label is opposite of the MajorLabel
//
//	/**
//	 * Adds a coordinate to the set of minor rectangles and updates both major and minor set of rectangles.
//	 * This function will automatically divide the major rectangles if necessary, and create or expand a
//	 * minor rectangle to include the recently added coordinate.
//	 */
//	void addMinorCoo (const Coordinate& coo);
//
//	/**
//	 * This function updates the vector of major rectangles by dividing the single major rectangle who surrounds the 
//	 * given coordination. Nothing will be done if no major rectangle surrounds the given coordination. The vector 
//	 * of major rectangles will be automatically updated. 
//	 * \return the number of new rectangles. -1 if error happens, 0 if no major rectangle surrounds the coo, 2, 3 or 4
//	 * if rectangle needs to break down.
//	 * NOTE: It is not very optimized now. It divides in 8 new rectangles without merging those who can be merged.
//	 * remember to merge them later.
//	 */
//	int divideMajorsOn (const Coordinate& coo);
//
//public:
//	Ruleption(void);
//	Ruleption(const Ruleption& other);
//	Ruleption(const LongInstance& l1, const LongInstance& l2);	//!< NOTE: l1 and l2 are conflicting rules, with the same IF part and different lable
//	Ruleption(const LongInstance& l); //!< C'tor with only one LongInstance parameter. Assumes there is no conflicting rule.
//	~Ruleption();
//
//
//	/** Returns true is the given coordination exists in one of the sub-rectangles. */
//	bool hasException (const Coordinate& coo);
//
//	/** returns the label of the given coordination.
//	 *  This functions finds the rule (i.e.)long instance that includes the given coordination
//	 *  and returns the rule label (then-part) for it.
//	 */
//	int label (const Coordinate& coo) const;
//
//	/**
//	 * Returns true if the given IF part (as a Neighborhood vector) is the same as the IF part in this Ruletangle object.
//	 * i.e. if the rule of the ruletangle applies to this sample.
//	 */
//	bool applies (const vector<Neighborhood>& nbr) const;
//
//	/**
//	 * Returns the number of minor rectangles.
//	 */
//	int getMinorRectNum () const {return this->exception.size();}
//
//	/**
//	 * returns the number of coordinates in the minor longinstance (whose label is dominant)
//	 */
//	int getMinorCooNum () const {}
//
//	/** Returns the minor rectangle whose index is given.*/
//	Rectangle getMinorRect (int index) const {return Rectangle(this->exception[index]);}
//
//	/** Prints the content of the object to the screen. */
//	void print(void) const;
//
//	/** Prints the detailed content of the object to the screen. */
//	void printDetail(void) const;
//};
//
//#endif /* RULETANGLE_H_ */
